﻿
namespace Forms.My
{
    using System.Windows.Forms;

    using Microsoft.VisualBasic;
    using Microsoft.VisualBasic.CompilerServices;

    using System;
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Diagnostics;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;

    [GeneratedCode("MyTemplate", "8.0.0.0"), HideModuleName, StandardModule]
    internal sealed class MyProject
    {
        private static readonly ThreadSafeObjectProvider<MyApplication> m_AppObjectProvider = new ThreadSafeObjectProvider<MyApplication>();
        private static readonly ThreadSafeObjectProvider<MyComputer> m_ComputerObjectProvider = new ThreadSafeObjectProvider<MyComputer>();
        private static ThreadSafeObjectProvider<MyForms> m_MyFormsObjectProvider = new ThreadSafeObjectProvider<MyForms>();

        [HelpKeyword("My.Application")]
        internal static MyApplication Application
        {
            [DebuggerHidden]
            get
            {
                return m_AppObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.Computer")]
        internal static MyComputer Computer
        {
            [DebuggerHidden]
            get
            {
                return m_ComputerObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.Forms")]
        internal static MyForms Forms
        {
            [DebuggerHidden]
            get
            {
                return m_MyFormsObjectProvider.GetInstance;
            }
        }

    

      

        [MyGroupCollection("System.Windows.Forms.Form", "Create__Instance__", "Dispose__Instance__", "My.MyProject.Forms"), EditorBrowsable(EditorBrowsableState.Never)]
        internal sealed class MyForms
        {
            [ThreadStatic]
            private static Hashtable m_FormBeingCreated;
            public frmAbloesen m_frmAbloesen;
            public frmAuswertung m_frmAuswertung;
            public frmBestand m_frmBestand;
            public frmBMW m_frmBMW;
            public frmBMWDebKonten m_frmBMWDebKonten;
            public frmBMWKomplett m_frmBMWKomplett;
            public frmDebug m_frmDebug;
            public frmDebugDataSet m_frmDebugDataSet;
            public frmDebugPasswort m_frmDebugPasswort;
            public frmDruck m_frmDruck;
            public frmEasy m_frmEasy;
            public frmF1 m_frmF1;
            public frmF1_Auswertung m_frmF1_Auswertung;
            public frmFA m_frmFA;
            public frmFA_Add m_frmFA_Add;
            public frmHistorie m_frmHistorie;
            public frmInternalFunctions m_frmInternalFunctions;
            public frmPfade m_frmPfade;
            public frmProtokoll m_frmProtokoll;
            public frmSplashScreen m_frmSplashScreen;
            public Main m_Main;

            [DebuggerHidden]
            private static T Create__Instance__<T>(T Instance) where T: Form, new()
            {
                T local;
                if ((Instance != null) && !Instance.IsDisposed)
                {
                    return Instance;
                }
                if (m_FormBeingCreated != null)
                {
                    if (m_FormBeingCreated.ContainsKey(typeof(T)))
                    {
                        throw new InvalidOperationException(Utils.GetResourceString("WinForms_RecursiveFormCreate", new string[0]));
                    }
                }
                else
                {
                    m_FormBeingCreated = new Hashtable();
                }
                m_FormBeingCreated.Add(typeof(T), null);
                try
                {
                    local = Activator.CreateInstance<T>();
                }
                catch (TargetInvocationException exception)
                {
                    
                    throw new InvalidOperationException(Utils.GetResourceString("WinForms_SeeInnerException", new string[] { exception.InnerException.Message }), exception.InnerException);
                }
                finally
                {
                    m_FormBeingCreated.Remove(typeof(T));
                }
                return local;
            }

            [DebuggerHidden]
            private void Dispose__Instance__<T>(ref T instance) where T: Form
            {
                instance.Dispose();
                instance = default(T);
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            public override bool Equals(object o)
            {
                return base.Equals(RuntimeHelpers.GetObjectValue(o));
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            public override int GetHashCode()
            {
                return base.GetHashCode();
            }


            [EditorBrowsable(EditorBrowsableState.Never)]
            public override string ToString()
            {
                return base.ToString();
            }

            public frmAbloesen frmAbloesen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmAbloesen = Create__Instance__<frmAbloesen>(this.m_frmAbloesen);
                    return this.m_frmAbloesen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmAbloesen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmAbloesen>(ref this.m_frmAbloesen);
                    }
                }
            }

            public frmAuswertung frmAuswertung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmAuswertung = Create__Instance__<frmAuswertung>(this.m_frmAuswertung);
                    return this.m_frmAuswertung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmAuswertung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmAuswertung>(ref this.m_frmAuswertung);
                    }
                }
            }

            public frmBestand frmBestand
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmBestand = Create__Instance__<frmBestand>(this.m_frmBestand);
                    return this.m_frmBestand;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmBestand)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmBestand>(ref this.m_frmBestand);
                    }
                }
            }

            public frmBMW frmBMW
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmBMW = Create__Instance__<frmBMW>(this.m_frmBMW);
                    return this.m_frmBMW;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmBMW)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmBMW>(ref this.m_frmBMW);
                    }
                }
            }

            public frmBMWDebKonten frmBMWDebKonten
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmBMWDebKonten = Create__Instance__<frmBMWDebKonten>(this.m_frmBMWDebKonten);
                    return this.m_frmBMWDebKonten;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmBMWDebKonten)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmBMWDebKonten>(ref this.m_frmBMWDebKonten);
                    }
                }
            }

            public frmBMWKomplett frmBMWKomplett
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmBMWKomplett = Create__Instance__<frmBMWKomplett>(this.m_frmBMWKomplett);
                    return this.m_frmBMWKomplett;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmBMWKomplett)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmBMWKomplett>(ref this.m_frmBMWKomplett);
                    }
                }
            }

            public frmDebug frmDebug
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmDebug = Create__Instance__<frmDebug>(this.m_frmDebug);
                    return this.m_frmDebug;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmDebug)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmDebug>(ref this.m_frmDebug);
                    }
                }
            }

            public frmDebugDataSet frmDebugDataSet
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmDebugDataSet = Create__Instance__<frmDebugDataSet>(this.m_frmDebugDataSet);
                    return this.m_frmDebugDataSet;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmDebugDataSet)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmDebugDataSet>(ref this.m_frmDebugDataSet);
                    }
                }
            }

            public frmDebugPasswort frmDebugPasswort
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmDebugPasswort = Create__Instance__<frmDebugPasswort>(this.m_frmDebugPasswort);
                    return this.m_frmDebugPasswort;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmDebugPasswort)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmDebugPasswort>(ref this.m_frmDebugPasswort);
                    }
                }
            }

            public frmDruck frmDruck
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmDruck = Create__Instance__<frmDruck>(this.m_frmDruck);
                    return this.m_frmDruck;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmDruck)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmDruck>(ref this.m_frmDruck);
                    }
                }
            }

            public frmEasy frmEasy
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmEasy = Create__Instance__<frmEasy>(this.m_frmEasy);
                    return this.m_frmEasy;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmEasy)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmEasy>(ref this.m_frmEasy);
                    }
                }
            }

            public frmF1 frmF1
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmF1 = Create__Instance__<frmF1>(this.m_frmF1);
                    return this.m_frmF1;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmF1)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmF1>(ref this.m_frmF1);
                    }
                }
            }

            public frmF1_Auswertung frmF1_Auswertung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmF1_Auswertung = Create__Instance__<frmF1_Auswertung>(this.m_frmF1_Auswertung);
                    return this.m_frmF1_Auswertung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmF1_Auswertung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmF1_Auswertung>(ref this.m_frmF1_Auswertung);
                    }
                }
            }

            public frmFA frmFA
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmFA = Create__Instance__<frmFA>(this.m_frmFA);
                    return this.m_frmFA;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmFA)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmFA>(ref this.m_frmFA);
                    }
                }
            }

            public frmFA_Add frmFA_Add
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmFA_Add = Create__Instance__<frmFA_Add>(this.m_frmFA_Add);
                    return this.m_frmFA_Add;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmFA_Add)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmFA_Add>(ref this.m_frmFA_Add);
                    }
                }
            }

            public frmHistorie frmHistorie
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmHistorie = Create__Instance__<frmHistorie>(this.m_frmHistorie);
                    return this.m_frmHistorie;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmHistorie)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmHistorie>(ref this.m_frmHistorie);
                    }
                }
            }

            public frmInternalFunctions frmInternalFunctions
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmInternalFunctions = Create__Instance__<frmInternalFunctions>(this.m_frmInternalFunctions);
                    return this.m_frmInternalFunctions;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmInternalFunctions)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmInternalFunctions>(ref this.m_frmInternalFunctions);
                    }
                }
            }

            public frmPfade frmPfade
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmPfade = Create__Instance__<frmPfade>(this.m_frmPfade);
                    return this.m_frmPfade;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmPfade)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmPfade>(ref this.m_frmPfade);
                    }
                }
            }

            public frmProtokoll frmProtokoll
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmProtokoll = Create__Instance__<frmProtokoll>(this.m_frmProtokoll);
                    return this.m_frmProtokoll;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmProtokoll)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmProtokoll>(ref this.m_frmProtokoll);
                    }
                }
            }

            public frmSplashScreen frmSplashScreen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_frmSplashScreen = Create__Instance__<frmSplashScreen>(this.m_frmSplashScreen);
                    return this.m_frmSplashScreen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_frmSplashScreen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<frmSplashScreen>(ref this.m_frmSplashScreen);
                    }
                }
            }

            public Main Main
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Main = Create__Instance__<Main>(this.m_Main);
                    return this.m_Main;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Main)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<Main>(ref this.m_Main);
                    }
                }
            }
        }

 
        [ComVisible(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal sealed class ThreadSafeObjectProvider<T> where T: new()
        {
            [CompilerGenerated, ThreadStatic]
            private static T m_ThreadStaticValue;

            internal T GetInstance
            {
                [DebuggerHidden]
                get
                {
                    if (MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue == null)
                    {
                        MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue = Activator.CreateInstance<T>();
                    }
                    return MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue;
                }
            }
        }
    }
}

